home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / alpha / dipc / dipc-0.000 / dipc-0 / dipc-0.15 / dipcd / support.c < prev    next >
C/C++ Source or Header  |  1996-07-16  |  10KB  |  459 lines
  1.  
  2. /*
  3.  * support.c
  4.  *
  5.  * part of dipcd source code
  6.  *
  7.  * Copyright (C) Kamran Karimi
  8.  */
  9.  
  10. #include "dipcd.h"
  11. #include "funcs.h"
  12.  
  13. extern struct sockaddr_in MY_LBACK, REFEREE_LBACK;
  14. extern struct sockaddr_in MY_ADDRESS, REFEREE_ADDRESS;
  15.  
  16. extern int verbose;
  17.  
  18. char mstr[160];
  19.  
  20. /* prints a message for the user */
  21. void mess(char *str, char *filename, int line)
  22. {
  23.  fprintf(stderr,"[%d@%s:%d]  %s\n",getpid(), filename, line, str);
  24. } 
  25.  
  26.  
  27. /** The following is for the support of heterogeneous systems **/
  28.  
  29. /* converts a 16 bit integer from big/little endian to little/big endian */
  30. /*static*/ short endian16(short to_convert)
  31. {
  32.  char temp;
  33.  union
  34.  {
  35.   short short_form;
  36.   char chr_form[2];
  37.  } conv;
  38.  
  39.  conv.short_form = to_convert;
  40.  temp = conv.chr_form[0];
  41.  conv.chr_form[0] = conv.chr_form[1];
  42.  conv.chr_form[1] = temp;
  43.  
  44.  return conv.short_form;
  45. }
  46.  
  47. /* converts a 32 bit integer from big/little endian to little/big endian */
  48. /*static*/ int endian32(int to_convert)
  49. {
  50.  char temp;
  51.  union
  52.  {
  53.   int int_form;
  54.   char chr_form[4];
  55.  } conv;
  56.  
  57.  conv.int_form = to_convert;
  58.  temp = conv.chr_form[0];
  59.  conv.chr_form[0] = conv.chr_form[3];
  60.  conv.chr_form[3] = temp;
  61.  temp = conv.chr_form[1];
  62.  conv.chr_form[1] = conv.chr_form[2];
  63.  conv.chr_form[2] = temp;
  64.  
  65.  return conv.int_form;
  66. }
  67.  
  68. /* put here the code to convert the fields of a message structure to
  69.    the receiving machine's suitable form. message.arch has the architecture
  70.    of the sender machine. MY_DIPC_ARCH has the architecture of this machine.*/ 
  71. static void convert_message(struct message *message)
  72. {
  73.  
  74.  if(message->arch == MY_DIPC_ARCH)
  75.   return;
  76.  /* else convert (struct message*) message */
  77. } 
  78.  
  79. /* this routine is the place where data conversions for different computer
  80.    architectures are done. This is done after we have converted the message 
  81.    itself. see above. */
  82. static void convert_data(char *data, struct message *message)
  83. { 
  84.  if(message->arch == MY_DIPC_ARCH)
  85.   return;
  86.  switch(message->info.func)
  87.  {
  88.   case SEMCTL:
  89.   /* 'message->info.arg2' has the second (semnum) argument */
  90.    switch(message->info.arg3)
  91.    {
  92.     case SETVAL:
  93.      /* convert (int) message->info.arg4 */
  94.      break;
  95.    
  96.     case IPC_SET:
  97.     case IPC_STAT:      
  98.      /* convert (struct semid_ds *) data */
  99.      break;
  100.    
  101.     case SETALL:
  102.     case GETALL:
  103.      /* convert (ushort *)data */
  104.      break;
  105.    }
  106.    break;
  107.      
  108.   case SEMOP:
  109.    /* 'message->info.arg2' has the third (nops) argument */
  110.    /* convert (struct sembuf *) data */
  111.    break;
  112.  
  113.   case MSGCTL:
  114.    /* convert (struct msqid_ds *) data */
  115.    break;
  116.    
  117.   case SHMCTL:
  118.    /* (struct shmid_ds *) data */
  119.    break;
  120.   
  121.   default:
  122.    sprintf(mstr,"ERROR: Unknown Function");
  123.    mess(mstr, INFO);
  124.    break;
  125.  }  
  126. }   
  127. /** End of heterogeneous support routines **/
  128.  
  129.  
  130. char *work_string(int func)
  131. {
  132.  static char strings[23][11] = 
  133.  {
  134.   "SEMOP     ",
  135.   "SEMCTL    ",
  136.  
  137.   "MSGSND    ",
  138.   "MSGRCV    ",
  139.   "MSGCTL    ",
  140.  
  141.   "SHMCTL    ",
  142.  
  143.   "DISABLE_RD",
  144.   "DISABLE_WR",
  145.  
  146.   "WANTRD    ",
  147.   "WANTWR    ",
  148.   "DETACH    ",
  149.   "AK        ",
  150.   
  151.   "WRPROT_SND",
  152.   "RDPROT    ",
  153.   "RDPROT_SND",
  154.   "NOP_SND   ",
  155.   "RCV       ",
  156.   "TSTGET    ",
  157.   
  158.   "RMID      ",
  159.   "DELKEY    ",
  160.   "SEARCH    ",
  161.   "COMMIT    ",
  162.   "Bad Work  "
  163.  };
  164.  
  165.  switch(func)
  166.  {
  167.   case SEMOP: return strings[0];
  168.   case SEMCTL: return strings[1];
  169.  
  170.   case MSGSND: return strings[2];
  171.   case MSGRCV: return strings[3];
  172.   case MSGCTL: return strings[4];
  173.  
  174.   case SHMCTL: return strings[5];
  175.  
  176.   case DISABLE_RD: return strings[6];
  177.   case DISABLE_WR: return strings[7];
  178.   case WANTRD: return strings[8];
  179.   case WANTWR: return strings[9];
  180.   case DETACH: return strings[10];
  181.   case AK: return strings[11];
  182.   
  183.   case WRPROT_SND: return strings[12];
  184.   case RDPROT: return strings[13];
  185.   case RDPROT_SND: return strings[14];
  186.   case NOP_SND: return strings[15];
  187.   case RCV: return strings[16];
  188.   case TSTGET: return strings[17];
  189.   
  190.   case RMID: return strings[18];
  191.   case DELKEY: return strings[19];
  192.   case SEARCH: return strings[20];
  193.   case COMMIT: return strings[21];
  194.  
  195.   default:
  196.    break;
  197.  }
  198.  sprintf(mstr,"ERROR: Bad Work function: %d", func);
  199.  mess(mstr, INFO);
  200.  return strings[22];
  201. }
  202.  
  203.  
  204. char *request_string(int req)
  205. {
  206.  static char strings[7][12] = 
  207.  {
  208.   "REQ_SHMMAN ",
  209.   "RES_SHMMAN ",
  210.  
  211.   "REQ_REFEREE",
  212.   "RES_REFEREE",
  213.   
  214.   "REQ_DOWORK ",
  215.   "RES_DOWORK ",
  216.   
  217.   "Bad Request"
  218.  };
  219.  
  220.  switch(req)
  221.  {
  222.   case REQ_SHMMAN: return strings[0];
  223.   case RES_SHMMAN: return strings[1];
  224.  
  225.   case REQ_REFEREE: return strings[2];
  226.   case RES_REFEREE: return strings[3];
  227.   
  228.   case REQ_DOWORK: return strings[4];
  229.   case RES_DOWORK: return strings[5];
  230.  
  231.   default:
  232.    break;
  233.  }
  234.  sprintf(mstr,"ERROR: Bad Request: %d", req);
  235.  mess(mstr, INFO);
  236.  return strings[6];
  237. }
  238.  
  239. /* read nbytes from the network and put them in *ptr */
  240. int readn(int fd, char *ptr, int nbytes)
  241. {
  242.  int nleft, nread;
  243.  
  244.  nleft = nbytes;
  245.  while(nleft > 0)
  246.  {
  247.   nread = read(fd,ptr,nleft);
  248.   if(nread < 0)
  249.   {
  250.    if(errno != EINTR)
  251.     break;
  252.   }    
  253.   if(nread == 0) break;
  254.   if(nread > 0)
  255.   {
  256.    nleft -= nread;
  257.    ptr += nread;
  258.   } 
  259.  } 
  260.  return (nbytes - nleft);
  261. }  
  262.  
  263. /* send nbytes from *ptr to the network */
  264. int writen(int fd, char *ptr, int nbytes)
  265. {
  266.  int nleft,nwritten;
  267.  
  268.  nleft = nbytes;
  269.  while(nleft > 0)
  270.  {
  271.   nwritten = write(fd,ptr,nleft);
  272.   if(nwritten < 0)
  273.   {
  274.    if(errno != EINTR)
  275.     break;
  276.   }
  277.   if(nwritten == 0) break;
  278.   if(nwritten > 0)
  279.   {
  280.    nleft -= nwritten;
  281.    ptr += nwritten;
  282.   } 
  283.  } 
  284.  return (nbytes - nleft);
  285. }
  286.  
  287. /* prepare a socket to receive incoming conections */
  288. FD plug(int family, struct sockaddr *my_addr, int addr_len)
  289. {
  290.  FD sockfd;
  291.  
  292.  if((sockfd = socket(family,SOCK_STREAM,0)) < 0)
  293.  {
  294.   sprintf(mstr,"ERROR: socket() Failed  BECAUSE %s",strerror(errno));
  295.   mess(mstr, INFO); 
  296.   return BAD_FD;
  297.  }
  298.  if(bind(sockfd,my_addr,addr_len) < 0)
  299.  {
  300.   sprintf(mstr,"ERROR: bind() Failed  BECAUSE %s",strerror(errno));
  301.   mess(mstr, INFO);
  302.   close(sockfd);
  303.   return BAD_FD;
  304.  }
  305.  if(listen(sockfd,5) < -1)
  306.  {
  307.   sprintf(mstr,"ERROR: listen() Failed BECAUSE %s",strerror(errno));
  308.   mess(mstr, INFO);
  309.   close(sockfd);
  310.   return BAD_FD;
  311.  }
  312.  return sockfd;
  313. }
  314.  
  315. /* get a socket connection to another waiting one */ 
  316. FD ring(int family, struct sockaddr *addr, int addr_len)
  317. {
  318.  int sockfd;
  319.  sigset_t newmask, oldmask;
  320.  
  321.  sigemptyset(&newmask);
  322.  sigaddset(&newmask, SIGCHLD);
  323.  sigprocmask(SIG_BLOCK, &newmask, &oldmask);
  324.  while(1)
  325.  {
  326.   if((sockfd = socket(family,SOCK_STREAM,0)) < 0) 
  327.   {
  328.    if(errno != EINTR)
  329.    {
  330.     sprintf(mstr,"ERROR: socket() Failed  BECAUSE %s",strerror(errno));
  331.     mess(mstr, INFO);
  332.     sigprocmask(SIG_SETMASK, &oldmask, NULL);
  333.     return BAD_FD;
  334.    }
  335.   }
  336.   else break;
  337.  }
  338.  if(family == AF_INET)
  339.  {
  340.   if(SAME_ADDRESS((struct sockaddr_in *)addr, MY_ADDRESS))
  341.    (struct sockaddr_in *)addr = &MY_LBACK;
  342.   else if(SAME_ADDRESS((struct sockaddr_in *)addr, REFEREE_ADDRESS) && 
  343.           SAME_MACHINE((struct sockaddr_in *)addr,MY_ADDRESS))
  344.    (struct sockaddr_in *)addr = &REFEREE_LBACK;  
  345.  }   
  346.  /* connect() may not be able to restart in case of an intr */
  347.  while(1)
  348.  {
  349.   if(connect(sockfd, addr, addr_len) < 0)
  350.   {
  351.    if(errno != EINTR)
  352.    {
  353.     sprintf(mstr,"ERROR: connect() Failed  BECAUSE %s",strerror(errno));
  354.     mess(mstr, INFO);
  355.     close(sockfd);
  356.     sigprocmask(SIG_SETMASK, &oldmask, NULL);
  357.     return BAD_FD;
  358.    }
  359.   }
  360.   else break;
  361.  }
  362.  sigprocmask(SIG_SETMASK, &oldmask, NULL); 
  363.  return sockfd;
  364. }
  365.  
  366.  
  367. /* send the contents of a struct message over an internet connection */ 
  368. BOOLEAN send_in_message(struct message *message, struct sockaddr_in addr)
  369. { 
  370.  int in_sock;
  371.  int want_trans, act_trans;
  372.  
  373.  message->arch = MY_DIPC_ARCH;
  374.  message->reserved = -1;
  375.  in_sock = ring(AF_INET, (struct sockaddr *) &addr, sizeof(addr));
  376.  if(in_sock < 0)
  377.  {
  378.   sprintf(mstr,"ERROR: Can't Connect To Internet address BECAUSE %s",
  379.           strerror(errno));
  380.   mess(mstr, INFO);
  381.   return FAIL;
  382.  } 
  383.  want_trans = sizeof(*message);
  384.  act_trans = writen(in_sock, (char *)message, want_trans);
  385.  if(act_trans < want_trans)
  386.  {
  387.   sprintf(mstr,"ERROR: Sent %d From %d Bytes BECAUSE %s",
  388.           act_trans, want_trans,strerror(errno));
  389.   mess(mstr, INFO); 
  390.   close(in_sock);
  391.   return FAIL;
  392.  }
  393.  close(in_sock);
  394.  return SUCCESS;
  395. }
  396.   
  397. /* receive some data (for example message contents) over an internet 
  398.    connection */  
  399. int get_in_data(int in_sock, char *data, struct message *message)
  400. {
  401.  int act_trans;
  402.  
  403.  act_trans = readn(in_sock, data, message->info.dsize);
  404.  if(act_trans == message->info.dsize)
  405.   convert_data(data, message);
  406.  return act_trans;
  407. } 
  408.  
  409. /* receive an struct message from an internet connection */
  410. int get_in_message(int in_sock, struct message *message)
  411. {
  412.  int act_trans;
  413.  
  414.  act_trans = readn(in_sock, (char *)message, sizeof(struct message));
  415.  if(act_trans == sizeof(struct message))
  416.   convert_message(message);
  417.  return act_trans;
  418. } 
  419.  
  420. /* called from front_end.c and back_end.c, when a child exits */
  421. void child_handler(int signo)
  422. {
  423.  pid_t cpid;
  424.  
  425.  /* consider the possibility of multiple exits */
  426.  while((cpid = waitpid(-1, NULL, WNOHANG)) > 0)
  427.  {
  428.   if(verbose)
  429.   {
  430.    sprintf(mstr,"Child %d Exited",cpid);
  431.    mess(mstr, INFO);
  432.   } 
  433.  }
  434. }
  435.  
  436.  
  437. BOOLEAN become(char *user)
  438. {
  439.  struct passwd *pw;
  440.  
  441.  pw = getpwnam(user);
  442.  if(pw)
  443.  {
  444.   if((setegid(pw->pw_gid) < 0) || (seteuid(pw->pw_uid) < 0))
  445.   {
  446.    sprintf(mstr,"ERROR: Can't Become: %s, uid: %d, gid: %d. Because: %s",
  447.                    user, pw->pw_uid, pw->pw_gid, strerror(errno));
  448.    mess(mstr, INFO);
  449.    printf("euid %d  egid %d  uid %d  gid %d\n",geteuid(), getegid(),
  450.     getuid(), getgid());
  451.    return FAIL;
  452.   }
  453.   return SUCCESS;
  454.  }
  455.  sprintf(mstr,"ERROR: User '%s' Not Found", user);
  456.  mess(mstr, INFO);
  457.  return FAIL;
  458. }
  459.